<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Class template flat_multimap</title>
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../../index.html" title="The Boost C++ Libraries BoostBook Documentation Subset">
<link rel="up" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.flat__map_8hpp" title="Header &lt;boost/container/flat_map.hpp&gt;">
<link rel="prev" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">
<link rel="next" href="flat__map_8hpp_1a35a574832df18432816fd150388eaa6c.html" title="Macro BOOST_CONTAINER_STD_PAIR_IS_MOVABLE">
<meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
<td align="center"><a href="../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1container_1_1flat__map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.flat__map_8hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="flat__map_8hpp_1a35a574832df18432816fd150388eaa6c.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="refentry">
<a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap"></a><div class="titlepage"></div>
<div class="refnamediv">
<h2><span class="refentrytitle">Class template flat_multimap</span></h2>
<p>boost::container::flat_multimap</p>
</div>
<h2 class="refsynopsisdiv-title">Synopsis</h2>
<div class="refsynopsisdiv"><pre class="synopsis"><span class="comment">// In header: &lt;<a class="link" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.flat__map_8hpp" title="Header &lt;boost/container/flat_map.hpp&gt;">boost/container/flat_map.hpp</a>&gt;

</span><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Key<span class="special">,</span> <span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span><span class="special">,</span> 
         <span class="keyword">typename</span> AllocatorOrContainer <span class="special">=</span> <span class="identifier">new_allocator</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">&gt;</span> 
<span class="keyword">class</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
  <span class="comment">// types</span>
  <span class="keyword">typedef</span> <span class="identifier">Key</span>                                                    <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a53202790e67e721a6d632892dbc37b0b"></a><span class="identifier">key_type</span><span class="special">;</span>              
  <span class="keyword">typedef</span> <span class="identifier">T</span>                                                      <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6ed38d9d17d272df9265cbfaf055b330"></a><span class="identifier">mapped_type</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">Compare</span>                                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7a99aa8c42799441432d3994fbccb341"></a><span class="identifier">key_compare</span><span class="special">;</span>           
  <span class="keyword">typedef</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span>                                    <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7783317e4e719c274be10517ac4c6e93"></a><span class="identifier">value_type</span><span class="special">;</span>            
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2cb4bab597c90a517a260620ec642b2e"></a><span class="identifier">sequence_type</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">allocator_type</span>                          <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ada89b6fb1d0cfcb3f501ec22a05f483a"></a><span class="identifier">allocator_type</span><span class="special">;</span>        
  <span class="keyword">typedef</span> ::boost::container::allocator_traits<span class="special">&lt;</span> <span class="identifier">allocator_type</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a566805169621db51fba019e72b031939"></a><span class="identifier">allocator_traits_type</span><span class="special">;</span> 
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">pointer</span>                                 <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a528bc44d10917f4556da2b5edf2c2378"></a><span class="identifier">pointer</span><span class="special">;</span>               
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_pointer</span>                           <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ac6dfb752e006fc1401496594a0c8e5eb"></a><span class="identifier">const_pointer</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">reference</span>                               <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1afaa18523bd9252129045900bcc212f82"></a><span class="identifier">reference</span><span class="special">;</span>             
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_reference</span>                         <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad50ab527e8330631a636d8b843f05a2f"></a><span class="identifier">const_reference</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">size_type</span>                               <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a326b737e8289bbde8ac4f7ea05f1ae4d"></a><span class="identifier">size_type</span><span class="special">;</span>             
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">difference_type</span>                         <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2f2cc14c6c51939846442a73c9b17f4c"></a><span class="identifier">difference_type</span><span class="special">;</span>       
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a36fd508fe9736cc3301566a68b8e7ce9"></a><span class="identifier">stored_allocator_type</span><span class="special">;</span> 
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a76ccae1919a76c5dbfdcbfdc18972189"></a><span class="identifier">value_compare</span><span class="special">;</span>         
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">iterator</span>                                <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9a83d8b8a90832fc0e862dff8c06882a"></a><span class="identifier">iterator</span><span class="special">;</span>              
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_iterator</span>                          <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abbaa3f7515961f393c6d0e050920aa2c"></a><span class="identifier">const_iterator</span><span class="special">;</span>        
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">reverse_iterator</span>                        <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8adb74d47329dc30ffa13bea335292b1"></a><span class="identifier">reverse_iterator</span><span class="special">;</span>      
  <span class="keyword">typedef</span> <span class="identifier">sequence_type</span><span class="special">::</span><span class="identifier">const_reverse_iterator</span>                  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa6b9b7f2e5c26cefdd219029714a750a"></a><span class="identifier">const_reverse_iterator</span><span class="special">;</span>
  <span class="keyword">typedef</span> <span class="identifier">implementation_defined</span>                                 <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5dfe961423f1f3bfbc2e47e3f9ebfb2c"></a><span class="identifier">movable_value_type</span><span class="special">;</span>    

  <span class="comment">// <a class="link" href="classboost_1_1container_1_1flat__multimap.html#id29-bb">public member functions</a></span>
   <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a017ae6d269b501c38b87c69db7274740"><span class="identifier">BOOST_CONTAINER_STATIC_ASSERT</span></a><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5aa6828f8a6adf69489d9df3484eb1ab"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">explicit</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa5750bd61446e8a80814784e56c59485"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">explicit</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab3188724e83710c477646cd27043e9f1"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a32eaff18745e94bf7bfa3ee054236a2b"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa717234fd4ea1851dd093a08091b877d"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af6c174db6295566e2e6ee60e997fd9df"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a036d7d4bb01cc0ef3699265270bc6146"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7e69d1da703601eba5a5c67a94b27266"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2920e27bd9467e2c2bde45307f51b423"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a56a74a015e1008ae480ffd8feba3b3bb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad0b20c96f9a77eea5bd1c324d2db8229"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3fb9fd11b42ac7333d9615afd49596e6"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> 
                  <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a58c7e725c58607f64b9dac05f79826e1"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9878939f4dab61bb8073400525dfd0a6"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3ed0b8b8a66ebaead87e094475b388dc"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a58784e79f9a8c1726c47bd196b0075ae"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ace1a3d4f6b4297d002dc0e25dfb6aaeb"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1120cb58f47f855be5a9bbb3508b9a70"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a558aaf34eee66d3c35a7cf4aabe11627"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab827bf4fbf45fdfedaf6072b7de87da6"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9b57475cb2061c004472d5221f2375f1"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4429dff5e45c244822cbe285de35747e"><span class="identifier">flat_multimap</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a937a250b822203703855ad5e07810ce6"><span class="identifier">flat_multimap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a36c9ea6caac071b6a42a720d098b1d3d"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1e8b4d36bec6d4e45d3950d147918baa"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7d9e0a803611f5fd93f31dd82cd6c60a"><span class="keyword">operator</span><span class="special">=</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">allocator_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834"><span class="identifier">get_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ac9b15ba7d85df04e5550f08e07c79d97"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a155a42eef5331a4d50ca5fc719f20249"><span class="identifier">get_stored_allocator</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a551082bcde83d4fa6c5648cc4ba151ea"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ae485c5676ebfbcbc4553ae33e4cb4956"><span class="identifier">begin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a22e75011d98bb3a126f8b953a45ad99d"><span class="identifier">end</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1f71ac39dc4d5e3281ed86126a39cf9f"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a353d5a253db35dcf464efcdeacbe6220"><span class="identifier">rbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6f09b70e0bdba1f029112486a669d421"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a860564129fae6a69ab491ccfcfd41cf6"><span class="identifier">rend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6bdd724b72150bbc34d66bcc6b6fe6d2"><span class="identifier">cbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7ebeca20bee0fa73fe34a7bea7e63564"><span class="identifier">cend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af1eee90866a9ab3da4b8231659542f1b"><span class="identifier">crbegin</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_reverse_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aac0ec9d48cf07af8ae223ff2b207529a"><span class="identifier">crend</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7b35ce55aa2b89c3c110806fb51ddee9"><span class="identifier">empty</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0"><span class="identifier">size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af8ab6478bf39c478b8f75979c711d63c"><span class="identifier">max_size</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626"><span class="identifier">capacity</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8be7c816898a53b72224ad935540f84f"><span class="identifier">reserve</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4f49fc47fa6353de078a09d5a9c0a490"><span class="identifier">shrink_to_fit</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab43580cd7f8b7575ee5335aff9460ad8"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a54d385f5d66699295a197320cfe89d0a"><span class="identifier">nth</span></a><span class="special">(</span><span class="identifier">size_type</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abd096ad2d9b4cfbe993d56d4708e1c53"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">iterator</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abafc7844b7030b33e2310808e39d936e"><span class="identifier">index_of</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1afa83701c62ab2eabb5e45c3bc7a6cf7a"><span class="identifier">emplace</span></a><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a490d1c86c16d5acd3d9cf4a455810f57"><span class="identifier">emplace_hint</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8496f6217f16dcee2b4bae55b9f79d6a"><span class="identifier">insert</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4204bb28f5a7cf60e6f27ab014584c7a"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">Pair</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a720e1c096300371274d6e7755dfeb45c"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1126acd852d094146da45b322fed876a"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">Pair</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9c327a4de55a87166003a0d4bce32e48"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7768fc756f9f16eba62abf1f5e5e793e"><span class="identifier">insert</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">,</span> <span class="identifier">InputIterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa2bc51536a94647c8d36145093951c5a"><span class="identifier">insert</span></a><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab2f5b1e5cc0eb98fc6a0d2631d718a69"><span class="identifier">insert</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa3f8c726b874e85b5c2bd6e7cab25ace"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a49fa3f2327aa0295c797eb1d3770c887"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aca9ee5e21096bd4027af46b4cf190008"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
    <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af9760bc5a1034f09426c5797faee3c2b"><span class="identifier">merge</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a19c5094f78018ab136b9a8f35f8f1fda"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad00cfb3f0237dc35de7941bc2473110a"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0933d6eef52ca61e1b75e37a1b451379"><span class="identifier">erase</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5920e3ef8fd00e09b9a4e6d6c3665d08"><span class="identifier">erase</span></a><span class="special">(</span><span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7e2078f0e1600d9152f0d7b64eabb1bb"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a556f0ff3f3f84e29f3049e142a604f6d"><span class="identifier">clear</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span>
  <span class="identifier">key_compare</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4713af004c9478786a7cd63ef44c22f1"><span class="identifier">key_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">value_compare</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a99bc93ad4174618b25b0ac5db1a449e6"><span class="identifier">value_comp</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1afb602c8426b35928b9dfe29228f6b76f"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad3d1609cc8e4935cc8b5e59ee859bec6"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71fca41812785f8985ab17b7dd17e1a1"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a52a31b8e62985138724c7f1717b9f8f5"><span class="identifier">find</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5bb1a8bf54df95dd2179ca4ec62f41d6"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af3eecdd55f2667fb79df7f65123e419d"><span class="identifier">count</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1403f3321bf8fc12ac0a70e71ef9ff4a"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a69b1b58a9b47f0b1a71a443e727fb211"><span class="identifier">contains</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa3dd2ee8a078d04e3ff99135b29e7f09"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2f44ac3a156526c189a19a980fd5a979"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a88adf36993b4ed2ddf52ef28921ff854"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a85789c21a00d983197e76d863d733bb9"><span class="identifier">lower_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9045698af138eadf20e69f8c6c629c31"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2f07ec2cf15434c939bc8988e6add934"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abde0535d898d4d5f19767fe780f79bf9"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a372ad917bdc92d4a930674c3d422d180"><span class="identifier">upper_bound</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a56cf2e3007c20d09f6fb70554eb7f8b4"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
  <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6d6000f1e5289b83afe25d9e95e8aff9"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1adb70d6e58a65c5c67d70334732d01114"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> 
    <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1632c9ca9ef4db79f6e44443a35ea73b"><span class="identifier">equal_range</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span>
  <span class="identifier">sequence_type</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aeb4d1478b4f9ec0fbac43647c59dc5a0"><span class="identifier">extract_sequence</span></a><span class="special">(</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9a98c374e9caf228ec6ae5f7d7209375"><span class="identifier">adopt_sequence</span></a><span class="special">(</span><span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a696b03d23f7ea13023a5f499d90f01f5"><span class="identifier">adopt_sequence</span></a><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">const</span> <span class="identifier">sequence_type</span> <span class="special">&amp;</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8c9a84643a7f96465d0b6c1c11688d3d"><span class="identifier">sequence</span></a><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span>

  <span class="comment">// <a class="link" href="classboost_1_1container_1_1flat__multimap.html#id30-bb">friend functions</a></span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3562445dca463e3beb0e4a05ffcbd193"><span class="keyword">operator</span><span class="special">==</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a502d81542ed1d3eb34c7306252cbf641"><span class="keyword">operator</span><span class="special">!=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ac9fcda862ed221e12885239a442d35b8"><span class="keyword">operator</span><span class="special">&lt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa50fc5f66b8aa1e30302d61620134c19"><span class="keyword">operator</span><span class="special">&gt;</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad1d51b9c6531638dcbdd3fb275845136"><span class="keyword">operator</span><span class="special">&lt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">bool</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab45122a250f9986ad0d80f29c1e558fd"><span class="keyword">operator</span><span class="special">&gt;=</span></a><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
  <span class="keyword">void</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af4f4c6f420eff49ea8467c46a44e0928"><span class="identifier">swap</span></a><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
<span class="special">}</span><span class="special">;</span></pre></div>
<div class="refsect1">
<a name="id-1.3.8.14.10.5.4"></a><h2>Description</h2>
<p>A <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys.</p>
<p>A <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> satisfies all of the requirements of a container and of a reversible container and of an associative container. For a flat_multimap&lt;Key,T&gt; the key_type is Key and the value_type is std::pair&lt;Key,T&gt; (unlike std::multimap&lt;Key, T&gt; which value_type is std::pair&lt;<span class="bold"><strong>const</strong></span> Key, T&gt;).</p>
<p><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> is similar to std::multimap but it's implemented by as an ordered sequence container. The underlying sequence container is by default <span class="emphasis"><em>vector</em></span> but it can also work user-provided vector-like SequenceContainers (like <span class="emphasis"><em><a class="link" href="classboost_1_1container_1_1static__vector.html" title="Class template static_vector">static_vector</a></em></span> or <span class="emphasis"><em><a class="link" href="classboost_1_1container_1_1small__vector.html" title="Class template small_vector">small_vector</a></em></span>).</p>
<p>Using vector-like sequence containers means that inserting a new element into a <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> might invalidate previous iterators and references (unless that sequence container is <span class="emphasis"><em><a class="link" href="classboost_1_1container_1_1stable__vector.html" title="Class template stable_vector">stable_vector</a></em></span> or a similar container that offers stable pointers and references). Similarly, erasing an element might invalidate iterators and references pointing to elements that come after (their keys are bigger) the erased element.</p>
<p>This container provides random-access iterators.</p>
<p>
</p>
<div class="refsect2">
<a name="id-1.3.8.14.10.5.4.8"></a><h3>Template Parameters</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Key</pre>
<p>is the key_type of the map </p>
</li>
<li class="listitem"><pre class="literallayout"><span class="keyword">typename</span> T</pre></li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> Compare <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span><span class="special">&lt;</span><span class="identifier">Key</span><span class="special">&gt;</span></pre>
<p>is the ordering function for Keys (e.g. <span class="emphasis"><em>std::less&lt;Key&gt;</em></span>). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">typename</span> AllocatorOrContainer <span class="special">=</span> <span class="identifier">new_allocator</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span></pre>
<p>is either:</p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem"><p>The allocator to allocate <code class="computeroutput">value_type</code>s (e.g. <span class="emphasis"><em>allocator&lt; std::pair&lt;Key, T&gt; &gt; </em></span>). (in this case <span class="emphasis"><em>sequence_type</em></span> will be vector&lt;value_type, AllocatorOrContainer&gt;)</p></li>
<li class="listitem"><p>The SequenceContainer to be used as the underlying <span class="emphasis"><em>sequence_type</em></span>. It must be a vector-like sequence container with random-access iterators. </p></li>
</ul></div>
<p>
</p>
</li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.8.14.10.5.4.9"></a><h3>
<a name="id29-bb"></a><code class="computeroutput">flat_multimap</code> public member functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem"><pre class="literallayout"> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a017ae6d269b501c38b87c69db7274740"></a><span class="identifier">BOOST_CONTAINER_STATIC_ASSERT</span><span class="special">(</span><span class="special">(</span><span class="identifier">dtl</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">,</span> <span class="identifier">value_type</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">value</span><span class="special">)</span><span class="special">)</span><span class="special">;</span></pre></li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5aa6828f8a6adf69489d9df3484eb1ab"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Default constructs an empty <a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">explicit</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa5750bd61446e8a80814784e56c59485"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified allocator.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">explicit</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab3188724e83710c477646cd27043e9f1"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object .</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a32eaff18745e94bf7bfa3ee054236a2b"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and allocator.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa717234fd4ea1851dd093a08091b877d"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af6c174db6295566e2e6ee60e997fd9df"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified allocator, and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a036d7d4bb01cc0ef3699265270bc6146"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7e69d1da703601eba5a5c67a94b27266"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and allocator, and inserts elements from the range [first ,last ).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [first ,last ) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2920e27bd9467e2c2bde45307f51b423"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a56a74a015e1008ae480ffd8feba3b3bb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad0b20c96f9a77eea5bd1c324d2db8229"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3fb9fd11b42ac7333d9615afd49596e6"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">,</span> 
                <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and inserts elements from the ordered range [first ,last). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a58c7e725c58607f64b9dac05f79826e1"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a> and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9878939f4dab61bb8073400525dfd0a6"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> 
              <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a> using the specified allocator, and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3ed0b8b8a66ebaead87e094475b388dc"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a> using the specified comparison object and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a58784e79f9a8c1726c47bd196b0075ae"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> 
              <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a> using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N if the range [il.begin(), il.end()) is already sorted using the predicate and otherwise N logN, where N is last - first. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ace1a3d4f6b4297d002dc0e25dfb6aaeb"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1120cb58f47f855be5a9bbb3508b9a70"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> 
              <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a558aaf34eee66d3c35a7cf4aabe11627"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">,</span> 
              <span class="keyword">const</span> <span class="identifier">Compare</span> <span class="special">&amp;</span> comp<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Constructs an empty <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified comparison object and allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in N.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab827bf4fbf45fdfedaf6072b7de87da6"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9b57475cb2061c004472d5221f2375f1"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Move constructs a <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a>. Constructs *this using x's resources.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: x is emptied. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4429dff5e45c244822cbe285de35747e"></a><span class="identifier">flat_multimap</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Copy constructs a <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified allocator.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a937a250b822203703855ad5e07810ce6"></a><span class="identifier">flat_multimap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">allocator_type</span> <span class="special">&amp;</span> a<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Move constructs a <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> using the specified allocator. Constructs *this using x's resources.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant if a == x.get_allocator(), linear otherwise. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a36c9ea6caac071b6a42a720d098b1d3d"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Makes *this a copy of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in x.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1e8b4d36bec6d4e45d3950d147918baa"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: this-&gt;swap(x.get()).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7d9e0a803611f5fd93f31dd82cd6c60a"></a><span class="keyword">operator</span><span class="special">=</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Assign content of il to *this</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in il.size(). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">allocator_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834"></a><span class="identifier">get_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a copy of the allocator that was passed to the object's constructor.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ac9b15ba7d85df04e5550f08e07c79d97"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">const</span> <span class="identifier">stored_allocator_type</span> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a155a42eef5331a4d50ca5fc719f20249"></a><span class="identifier">get_stored_allocator</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reference to the internal allocator.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a551082bcde83d4fa6c5648cc4ba151ea"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ae485c5676ebfbcbc4553ae33e4cb4956"></a><span class="identifier">begin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a22e75011d98bb3a126f8b953a45ad99d"></a><span class="identifier">end</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1f71ac39dc4d5e3281ed86126a39cf9f"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a353d5a253db35dcf464efcdeacbe6220"></a><span class="identifier">rbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6f09b70e0bdba1f029112486a669d421"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a860564129fae6a69ab491ccfcfd41cf6"></a><span class="identifier">rend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6bdd724b72150bbc34d66bcc6b6fe6d2"></a><span class="identifier">cbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the first element contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7ebeca20bee0fa73fe34a7bea7e63564"></a><span class="identifier">cend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the end of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af1eee90866a9ab3da4b8231659542f1b"></a><span class="identifier">crbegin</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the beginning of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_reverse_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aac0ec9d48cf07af8ae223ff2b207529a"></a><span class="identifier">crend</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_reverse_iterator pointing to the end of the reversed container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7b35ce55aa2b89c3c110806fb51ddee9"></a><span class="identifier">empty</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if the container contains no elements.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0"></a><span class="identifier">size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the number of the elements contained in the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af8ab6478bf39c478b8f75979c711d63c"></a><span class="identifier">max_size</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the largest possible size of the container.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626"></a><span class="identifier">capacity</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Number of elements for which memory has been allocated. <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626">capacity()</a> is always greater than or equal to <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8be7c816898a53b72224ad935540f84f"></a><span class="identifier">reserve</span><span class="special">(</span><span class="identifier">size_type</span> cnt<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: If n is less than or equal to <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626">capacity()</a>, or the underlying container has no <code class="computeroutput">reserve</code> member, this call has no effect. Otherwise, it is a request for allocation of additional memory. If the request is successful, then <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626">capacity()</a> is greater than or equal to n; otherwise, <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626">capacity()</a> is unchanged. In either case, <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> is unchanged.</p>
<p><span class="bold"><strong>Throws</strong></span>: If memory allocation allocation throws or T's copy constructor throws.</p>
<p><span class="bold"><strong>Note</strong></span>: If <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1c3b8d9d3945ffaa42a3f8b95927f626">capacity()</a> is less than "cnt", iterators and references to to values might be invalidated. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4f49fc47fa6353de078a09d5a9c0a490"></a><span class="identifier">shrink_to_fit</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<span class="bold"><strong>Effects</strong></span>: Tries to deallocate the excess of memory created <p><span class="bold"><strong>Throws</strong></span>: If memory allocation throws, or T's copy constructor throws.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab43580cd7f8b7575ee5335aff9460ad8"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> &gt;= n.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns an iterator to the nth element from the beginning of the container. Returns <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if n == <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a54d385f5d66699295a197320cfe89d0a"></a><span class="identifier">nth</span><span class="special">(</span><span class="identifier">size_type</span> n<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> &gt;= n.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const_iterator to the nth element from the beginning of the container. Returns <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if n == <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abd096ad2d9b4cfbe993d56d4708e1c53"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">iterator</span> p<span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a551082bcde83d4fa6c5648cc4ba151ea">begin()</a> &lt;= p &lt;= <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> if p == <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abafc7844b7030b33e2310808e39d936e"></a><span class="identifier">index_of</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a551082bcde83d4fa6c5648cc4ba151ea">begin()</a> &lt;= p &lt;= <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>.</p>
<p><span class="bold"><strong>Effects</strong></span>: Returns the index of the element pointed by p and <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> if p == <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1afa83701c62ab2eabb5e45c3bc7a6cf7a"></a><span class="identifier">emplace</span><span class="special">(</span><span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...</span> Args<span class="special">&gt;</span> 
  <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a490d1c86c16d5acd3d9cf4a455810f57"></a><span class="identifier">emplace_hint</span><span class="special">(</span><span class="identifier">const_iterator</span> hint<span class="special">,</span> <span class="identifier">Args</span> <span class="special">&amp;&amp;</span><span class="special">...</span> args<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts an object of type T constructed with std::forward&lt;Args&gt;(args)... in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8496f6217f16dcee2b4bae55b9f79d6a"></a><span class="identifier">insert</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts x and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4204bb28f5a7cf60e6f27ab014584c7a"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">Pair</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a new value constructed from x and returns the iterator pointing to the newly inserted element.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a720e1c096300371274d6e7755dfeb45c"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">value_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a copy of x in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Pair<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1126acd852d094146da45b322fed876a"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">,</span> <span class="identifier">Pair</span> <span class="special">&amp;&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Inserts a value constructed from x in the container. p is a hint pointing to where the insert should start to search.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the element with key equivalent to the key of x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9c327a4de55a87166003a0d4bce32e48"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) .</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> InputIterator<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7768fc756f9f16eba62abf1f5e5e793e"></a><span class="identifier">insert</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">InputIterator</span> first<span class="special">,</span> <span class="identifier">InputIterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: first, last are not iterators into *this.</p>
<p><span class="bold"><strong>Requires</strong></span>: [first ,last) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [first,last) if and only if there is no element with key equivalent to the key of that element. This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa2bc51536a94647c8d36145093951c5a"></a><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()) .</p>
<p><span class="bold"><strong>Complexity</strong></span>: N log(N).</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab2f5b1e5cc0eb98fc6a0d2631d718a69"></a><span class="identifier">insert</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">initializer_list</span><span class="special">&lt;</span> <span class="identifier">value_type</span> <span class="special">&gt;</span> il<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: [il.begin(), il.end()) must be ordered according to the predicate.</p>
<p><span class="bold"><strong>Effects</strong></span>: inserts each element from the range [il.begin(), il.end()) if and only if there is no element with key equivalent to the key of that element. This function is more efficient than the normal range creation for ordered ranges.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear.</p>
<p><span class="bold"><strong>Note</strong></span>: If an element is inserted it might invalidate elements.</p>
<p><span class="bold"><strong>Note</strong></span>: Non-standard extension. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa3f8c726b874e85b5c2bd6e7cab25ace"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Move-inserts each element from source into *this a using the comparison object of *this.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> + source.size().</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates all iterators and references. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a49fa3f2327aa0295c797eb1d3770c887"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Move-inserts each element from source into *this a using the comparison object of *this.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> + source.size().</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates all iterators and references.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aca9ee5e21096bd4027af46b4cf190008"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Move-inserts each element from source into *this a using the comparison object of *this.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> + source.size().</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates all iterators and references.    </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> C2<span class="special">&gt;</span> 
  <span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af9760bc5a1034f09426c5797faee3c2b"></a><span class="identifier">merge</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__map.html" title="Class template flat_map">flat_map</a><span class="special">&lt;</span> <span class="identifier">Key</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">C2</span><span class="special">,</span> <span class="identifier">AllocatorOrContainer</span> <span class="special">&gt;</span> <span class="special">&amp;&amp;</span> source<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9ffe915c00e2840fd66761e077649834">get_allocator()</a> == source.get_allocator().</p>
<p><span class="bold"><strong>Effects</strong></span>: Move-inserts each element from source into *this a using the comparison object of *this.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear in this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> + source.size().</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates all iterators and references.       </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a19c5094f78018ab136b9a8f35f8f1fda"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> p<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases the element pointed to by p.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the elements with keys bigger than p</p>
<p><span class="bold"><strong>Note</strong></span>: Invalidates elements with keys not less than the erased element. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad00cfb3f0237dc35de7941bc2473110a"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases all elements in the container with key equivalent to x.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0933d6eef52ca61e1b75e37a1b451379"></a><span class="identifier">erase</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Effects</strong></span>: Erases all elements in the container with key equivalent to x.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns the number of erased elements. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5920e3ef8fd00e09b9a4e6d6c3665d08"></a><span class="identifier">erase</span><span class="special">(</span><span class="identifier">const_iterator</span> first<span class="special">,</span> <span class="identifier">const_iterator</span> last<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Erases all the elements in the range [first, last).</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns last.</p>
<p><span class="bold"><strong>Complexity</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>*N where N is the distance from first to last.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic search time plus erasure time linear to the elements with bigger keys. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7e2078f0e1600d9152f0d7b64eabb1bb"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Swaps the contents of *this and x.</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a556f0ff3f3f84e29f3049e142a604f6d"></a><span class="identifier">clear</span><span class="special">(</span><span class="special">)</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: erase(<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a551082bcde83d4fa6c5648cc4ba151ea">begin()</a>,<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a>).</p>
<p><span class="bold"><strong>Postcondition</strong></span>: <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a> == 0.</p>
<p><span class="bold"><strong>Complexity</strong></span>: linear in <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71eaaddd980571a988362c62e43f5fb0">size()</a>. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">key_compare</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a4713af004c9478786a7cd63ef44c22f1"></a><span class="identifier">key_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns the comparison object out of which a was constructed.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">value_compare</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a99bc93ad4174618b25b0ac5db1a449e6"></a><span class="identifier">value_comp</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns an object of value_compare constructed out of the comparison object.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1afb602c8426b35928b9dfe29228f6b76f"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad3d1609cc8e4935cc8b5e59ee859bec6"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An const_iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a71fca41812785f8985ab17b7dd17e1a1"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a52a31b8e62985138724c7f1717b9f8f5"></a><span class="identifier">find</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An const_iterator pointing to an element with the key equivalent to x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a5bb1a8bf54df95dd2179ca4ec62f41d6"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">size_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af3eecdd55f2667fb79df7f65123e419d"></a><span class="identifier">count</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: The number of elements with key equivalent to x.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size())+count(k) </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1403f3321bf8fc12ac0a70e71ef9ff4a"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a69b1b58a9b47f0b1a71a443e727fb211"></a><span class="identifier">contains</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: Returns true if there is an element with key equivalent to key in the container, otherwise false.</p>
<p><span class="bold"><strong>Complexity</strong></span>: log(size()). </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa3dd2ee8a078d04e3ff99135b29e7f09"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2f44ac3a156526c189a19a980fd5a979"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a88adf36993b4ed2ddf52ef28921ff854"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a85789c21a00d983197e76d863d733bb9"></a><span class="identifier">lower_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key not less than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9045698af138eadf20e69f8c6c629c31"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a2f07ec2cf15434c939bc8988e6add934"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1abde0535d898d4d5f19767fe780f79bf9"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: An iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">const_iterator</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a372ad917bdc92d4a930674c3d422d180"></a><span class="identifier">upper_bound</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Returns</strong></span>: A const iterator pointing to the first element with key greater than x, or <a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a0d4075322a99202f2c5ee1eabd8d0705">end()</a> if such an element is not found.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a56cf2e3007c20d09f6fb70554eb7f8b4"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> 
<a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a6d6000f1e5289b83afe25d9e95e8aff9"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">key_type</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1adb70d6e58a65c5c67d70334732d01114"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> K<span class="special">&gt;</span> 
  <span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span> <span class="identifier">const_iterator</span><span class="special">,</span> <span class="identifier">const_iterator</span> <span class="special">&gt;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a1632c9ca9ef4db79f6e44443a35ea73b"></a><span class="identifier">equal_range</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">K</span> <span class="special">&amp;</span> x<span class="special">)</span> <span class="keyword">const</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: This overload is available only if key_compare::is_transparent exists.</p>
<p><span class="bold"><strong>Effects</strong></span>: Equivalent to std::make_pair(this-&gt;lower_bound(k), this-&gt;upper_bound(k)).</p>
<p><span class="bold"><strong>Complexity</strong></span>: Logarithmic </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="identifier">sequence_type</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aeb4d1478b4f9ec0fbac43647c59dc5a0"></a><span class="identifier">extract_sequence</span><span class="special">(</span><span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Extracts the internal sequence container.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Same as the move constructor of sequence_type, usually constant.</p>
<p><span class="bold"><strong>Postcondition</strong></span>: this-&gt;<a class="link" href="classboost_1_1container_1_1flat__multimap.html#doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a7b35ce55aa2b89c3c110806fb51ddee9">empty()</a></p>
<p><span class="bold"><strong>Throws</strong></span>: If secuence_type's move constructor throws <br>
 </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a9a98c374e9caf228ec6ae5f7d7209375"></a><span class="identifier">adopt_sequence</span><span class="special">(</span><span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span> seq<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Discards the internally hold sequence container and adopts the one passed externally using the move assignment.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()</p>
<p><span class="bold"><strong>Throws</strong></span>: If the comparison or the move constructor throws </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a696b03d23f7ea13023a5f499d90f01f5"></a><span class="identifier">adopt_sequence</span><span class="special">(</span><a class="link" href="structboost_1_1container_1_1ordered__range__t.html" title="Struct ordered_range_t">ordered_range_t</a><span class="special">,</span> <span class="identifier">sequence_type</span> <span class="special">&amp;&amp;</span> seq<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Requires</strong></span>: seq shall be ordered according to this-&gt;compare().</p>
<p><span class="bold"><strong>Effects</strong></span>: Discards the internally hold sequence container and adopts the one passed externally using the move assignment.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Assuming O(1) move assignment, O(1)</p>
<p><span class="bold"><strong>Throws</strong></span>: If the move assignment throws </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">const</span> <span class="identifier">sequence_type</span> <span class="special">&amp;</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a8c9a84643a7f96465d0b6c1c11688d3d"></a><span class="identifier">sequence</span><span class="special">(</span><span class="special">)</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns a const view of the underlying sequence.</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant</p>
<p><span class="bold"><strong>Throws</strong></span>: Nothing </p>
</li>
</ol></div>
</div>
<div class="refsect2">
<a name="id-1.3.8.14.10.5.4.10"></a><h3>
<a name="id30-bb"></a><code class="computeroutput">flat_multimap</code> friend functions</h3>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a3562445dca463e3beb0e4a05ffcbd193"></a><span class="keyword">operator</span><span class="special">==</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are equal</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1a502d81542ed1d3eb34c7306252cbf641"></a><span class="keyword">operator</span><span class="special">!=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x and y are unequal</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ac9fcda862ed221e12885239a442d35b8"></a><span class="keyword">operator</span><span class="special">&lt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is less than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1aa50fc5f66b8aa1e30302d61620134c19"></a><span class="keyword">operator</span><span class="special">&gt;</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is greater than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ad1d51b9c6531638dcbdd3fb275845136"></a><span class="keyword">operator</span><span class="special">&lt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or less than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">bool</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1ab45122a250f9986ad0d80f29c1e558fd"></a><span class="keyword">operator</span><span class="special">&gt;=</span><span class="special">(</span><span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <span class="keyword">const</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: Returns true if x is equal or greater than y</p>
<p><span class="bold"><strong>Complexity</strong></span>: Linear to the number of elements in the container. </p>
</li>
<li class="listitem">
<pre class="literallayout"><span class="keyword">void</span> <a name="doxygen.boost_container_header_reference.classboost_1_1container_1_1flat__multimap_1af4f4c6f420eff49ea8467c46a44e0928"></a><span class="identifier">swap</span><span class="special">(</span><a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> x<span class="special">,</span> <a class="link" href="classboost_1_1container_1_1flat__multimap.html" title="Class template flat_multimap">flat_multimap</a> <span class="special">&amp;</span> y<span class="special">)</span><span class="special">;</span></pre>
<p><span class="bold"><strong>Effects</strong></span>: x.swap(y)</p>
<p><span class="bold"><strong>Complexity</strong></span>: Constant. </p>
</li>
</ol></div>
</div>
</div>
</div>
<div class="copyright-footer">Copyright © 2009-2018 Ion Gaztanaga<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="classboost_1_1container_1_1flat__map.html"><img src="../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../../boost_container_header_reference.html#doxygen.boost_container_header_reference.flat__map_8hpp"><img src="../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="flat__map_8hpp_1a35a574832df18432816fd150388eaa6c.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
